<HTML>
<!--
  -- Copyright (c) 1996-1999
  -- Silicon Graphics Computer Systems, Inc.
  --
  -- Permission to use, copy, modify, distribute and sell this software
  -- and its documentation for any purpose is hereby granted without fee,
  -- provided that the above copyright notice appears in all copies and
  -- that both that copyright notice and this permission notice appear
  -- in supporting documentation.  Silicon Graphics makes no
  -- representations about the suitability of this software for any
  -- purpose.  It is provided "as is" without express or implied warranty.
  --
  -- Copyright (c) 1994
  -- Hewlett-Packard Company
  --
  -- Permission to use, copy, modify, distribute and sell this software
  -- and its documentation for any purpose is hereby granted without fee,
  -- provided that the above copyright notice appears in all copies and
  -- that both that copyright notice and this permission notice appear
  -- in supporting documentation.  Hewlett-Packard Company makes no
  -- representations about the suitability of this software for any
  -- purpose.  It is provided "as is" without express or implied warranty.
  --
  -->
<Head>
<Title>insert_iterator&lt;Container&gt;</Title>
<!-- Generated by htmldoc -->
</HEAD>
<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
	ALINK="#ff0000"> 
<IMG SRC="CorpID.gif" 
     ALT="SGI" HEIGHT="43" WIDTH="151"> 
<!--end header-->
<BR Clear>
<H1>insert_iterator&lt;Container&gt;</H1>

<Table CellPadding=0 CellSpacing=0 width=100%>
<TR>
<TD Align=left><Img src = "iterators.gif" Alt=""   WIDTH = "194"  HEIGHT = "38" ></TD>
<TD Align=right><Img src = "type.gif" Alt=""   WIDTH = "194"  HEIGHT = "39" ></TD>
</TR>
<TR>
<TD Align=left><Img src = "adaptors.gif" Alt=""   WIDTH = "194"  HEIGHT = "38" ></TD>
<TD Align=right></TD>
</TR>
<TR>
<TD Align=left VAlign=top><b>Categories</b>: iterators, adaptors</TD>
<TD Align=right VAlign=top><b>Component type</b>: type</TD>
</TR>
</Table>

<h3>Description</h3>
<tt>Insert_iterator</tt> is an iterator adaptor that functions as an
<A href="OutputIterator.html">Output Iterator</A>: assignment through an <tt>insert_iterator</tt> inserts
an object into a <A href="Container.html">Container</A>.  Specifically, if <tt>ii</tt> is an
<tt>insert_iterator</tt>, then <tt>ii</tt> keeps track of a <A href="Container.html">Container</A> <tt>c</tt>
and an insertion point <tt>p</tt>; the expression <tt>*ii = x</tt> performs
the insertion <tt>c.insert(p, x)</tt>.  <A href="#1">[1]</A>
<P>
There are two different <A href="Container.html">Container</A> concepts that define this
expression: <A href="Sequence.html">Sequence</A>, and <A href="SortedAssociativeContainer.html">Sorted Associative Container</A>.
Both concepts define insertion into a container by means of
<tt>c.insert(p, x)</tt>, but the semantics of this expression is very 
different in the two cases.
<P>
For a <A href="Sequence.html">Sequence</A> <tt>S</tt>, the expression <tt>S.insert(p, x)</tt> means to
insert the value <tt>x</tt> <i>immediately before</i> the iterator <tt>p</tt>.  That
is, the two-argument version of <tt>insert</tt> allows you to control the
location at which the new element will be inserted.  For a
<A href="SortedAssociativeContainer.html">Sorted Associative Container</A>, however, no such control is
possible: the elements in a <A href="SortedAssociativeContainer.html">Sorted Associative Container</A> always
appear in ascending order of keys.  <A href="SortedAssociativeContainer.html">Sorted Associative Containers</A>
define the two-argument version of <tt>insert</tt> as an optimization.  The
first argument is only a hint: it points to the location where the 
search will begin.
<P>
If you assign through an <tt>insert_iterator</tt> several times, then you
will be inserting several elements into the underlying container.  In
the case of a <A href="Sequence.html">Sequence</A>, they will appear at a particular location
in the underlying sequence, in the order in which they were inserted:
one of the arguments to <tt>insert_iterator</tt>'s constructor is an iterator
<tt>p</tt>, and the new range will be inserted immediately before <tt>p</tt>.
<P>
In the case of a <A href="SortedAssociativeContainer.html">Sorted Associative Container</A>, however, the
iterator in the <tt>insert_iterator</tt>'s constructor is almost irrelevant.
The new elements will not necessarily form a contiguous range; they
will appear in the appropriate location in the container, in ascending
order by key.  The order in which they are inserted only affects 
efficiency: inserting an already-sorted range into a
<A href="SortedAssociativeContainer.html">Sorted Associative Container</A> is an <i>O(N</i>) operation.
<h3>Example</h3>
Insert a range of elements into a <tt><A href="List.html">list</A></tt>.
<pre>
<A href="List.html">list</A>&lt;int&gt; L;
L.push_front(3);
insert_iterator&lt;<A href="List.html">list</A>&lt;int&gt; &gt; ii(L, L.begin());
*ii++ = 0;
*ii++ = 1;
*ii++ = 2;
<A href="copy.html">copy</A>(L.begin(), L.end(), <A href="ostream_iterator.html">ostream_iterator</A>&lt;int&gt;(cout, &quot; &quot;));
// The values that are printed are 0 1 2 3.
</pre>
Merge two sorted lists, inserting the resulting range into a 
<tt><A href="set.html">set</A></tt>.  Note that a <tt><A href="set.html">set</A></tt> never contains duplicate
elements.
<pre>
int main() 
{
  const int N = 6;

  int A1[N] = {1, 3, 5, 7, 9, 11};
  int A2[N] = {1, 2, 3, 4, 5, 6};
  <A href="set.html">set</A>&lt;int&gt; result;

  <A href="merge.html">merge</A>(A1, A1 + N, A2, A2 + N, 
        inserter(result, result.begin()));
 
  <A href="copy.html">copy</A>(result.begin(), result.end(), <A href="ostream_iterator.html">ostream_iterator</A>&lt;int&gt;(cout, &quot; &quot;));
  cout &lt;&lt; endl;

  // The output is &quot;1 2 3 4 5 6 7 9 11&quot;.
}
</pre>
<h3>Definition</h3>
Defined in the standard header <A href="iterator">iterator</A>, and in the nonstandard
backward-compatibility header <A href="iterator.h">iterator.h</A>.
<h3>Template parameters</h3>
<Table border>
<TR>
<TH>
Parameter
</TH>
<TH>
Description
</TH>
<TH>
Default
</TH>
</TR>
<TR>
<TD VAlign=top>
<tt>Container</tt>
</TD>
<TD VAlign=top>
The type of Container into which values will be inserted.
</TD>
<TD VAlign=top>
&nbsp;
</TD>
</tr>
</table>
<h3>Model of</h3>
<A href="OutputIterator.html">Output Iterator</A>.  An insert iterator's set of value types (as
defined in the <A href="OutputIterator.html">Output Iterator</A> requirements) consists of
a single type: <tt><A href="Container.html">Container</A>::value_type</tt>.
<h3>Type requirements</h3>
<UL>
<LI>
The template parameter <tt>Container</tt> is a model of <A href="Container.html">Container</A>.
<LI>
<tt>Container</tt> is variable-sized, as described in the
   <A href="Container.html">Container</A> requirements.
<LI>
<tt>Container</tt> has a two-argument <tt>insert</tt> member function.
   Specifically, if <tt>c</tt> is an object of type <tt>Container</tt>, 
   <tt>p</tt> is an object of type <tt>Container::iterator</tt> and <tt>v</tt> is an
   object of type <tt>Container::value_type</tt>, then <tt>c.insert(p, v)</tt> 
   must be a valid expression.
</UL>
<h3>Public base classes</h3>
None.
<h3>Members</h3>
<Table border>
<TR>
<TH>
Member
</TH>
<TH>
Where defined
</TH>
<TH>
Description
</TH>
</TR>
<TR>
<TD VAlign=top>
<tt>insert_iterator(Container&amp;, Container::iterator)</tt>
</TD>
<TD VAlign=top>
<tt>insert_iterator</tt>
</TD>
<TD VAlign=top>
See below.
</TD>
</TR>
<TR>
<TD VAlign=top>
<tt>insert_iterator(const insert_iterator&amp;)</tt>
</TD>
<TD VAlign=top>
 <A href="trivial.html">Trivial Iterator</A>
</TD>
<TD VAlign=top>
The copy constructor
</TD>
</TR>
<TR>
<TD VAlign=top>
<tt>insert_iterator&amp; operator=(const insert_iterator&amp;)</tt>
</TD>
<TD VAlign=top>
 <A href="trivial.html">Trivial Iterator</A>
</TD>
<TD VAlign=top>
The assignment operator
</TD>
</TR>
<TR>
<TD VAlign=top>
<tt>insert_iterator&amp; operator*()</tt>
</TD>
<TD VAlign=top>
 <A href="OutputIterator.html">Output Iterator</A>
</TD>
<TD VAlign=top>
Used to implement the <A href="OutputIterator.html">output iterator</A> expression <tt>*i = x</tt>. <A href="#2">[2]</A>
</TD>
</TR>
<TR>
<TD VAlign=top>
<tt>insert_iterator&amp; operator=(const Container::value_type&amp;)</tt>
</TD>
<TD VAlign=top>
 <A href="OutputIterator.html">Output Iterator</A>
</TD>
<TD VAlign=top>
Used to implement the <A href="OutputIterator.html">output iterator</A> expression <tt>*i = x</tt>. <A href="#2">[2]</A>
</TD>
</TR>
<TR>
<TD VAlign=top>
<tt>insert_iterator&amp; operator++()</tt>
</TD>
<TD VAlign=top>
 <A href="OutputIterator.html">Output Iterator</A>
</TD>
<TD VAlign=top>
Preincrement.
</TD>
</TR>
<TR>
<TD VAlign=top>
<tt>insert_iterator&amp; operator++(int)</tt>
</TD>
<TD VAlign=top>
 <A href="OutputIterator.html">Output Iterator</A>
</TD>
<TD VAlign=top>
Postincrement.
</TD>
</TR>
<TR>
<TD VAlign=top>
<tt>output_iterator_tag iterator_category(const insert_iterator&amp;)</tt>
</TD>
<TD VAlign=top>
 <A href="iterator_tags.html">iterator tags</A>
</TD>
<TD VAlign=top>
Returns the iterator's category.
   This is a global function, not a member.
</TD>
</TR>
<TR>
<TD VAlign=top>
<pre>
template&lt;class Container, class Iter)
insert_iterator&lt;Container&gt;
inserter(Container&amp; C, Iter i);
</pre>
</TD>
<TD VAlign=top>
<tt>insert_iterator</tt>
</TD>
<TD VAlign=top>
See below.
</TD>
</tr>
</table>
<h3>New members</h3>
These members are not defined 
in the <A href="OutputIterator.html">Output Iterator</A> requirements,
but are specific to <tt>insert_iterator</tt>.
<Table border>
<TR>
<TH>
Member
</TH>
<TH>
Description
</TH>
</TR>
<TR>
<TD VAlign=top>
<tt>insert_iterator(Container&amp; C, Container::iterator i)</tt>
</TD>
<TD VAlign=top>
Constructs an <tt>insert_iterator</tt> that inserts objects in <tt>C</tt>.
   If <tt>Container</tt> is a <A href="Sequence.html">Sequence</A>, then each object will be 
   inserted immediately  before the element pointed to by <tt>i</tt>.  
   If <tt>C</tt> is a <A href="SortedAssociativeContainer.html">Sorted Associative Container</A>, then the first
   insertion will use <tt>i</tt> as a hint for beginning the search.
   The iterator <tt>i</tt> must be a dereferenceable or past-the-end
   iterator in <tt>C</tt>.
</TD>
</TR>
<TR>
<TD VAlign=top>
<pre>
template&lt;class Container, class Iter)
insert_iterator&lt;Container&gt;
inserter(Container&amp; C, Iter i);
</pre>
</TD>
<TD VAlign=top>
Equivalent to <tt>insert_iterator&lt;Container&gt;(C, i)</tt>.  <A href="#2">[2]</A>
   This is a global function, not a member function.
</TD>
</tr>
</table>
<h3>Notes</h3>
<P><A name="1">[1]</A>
Note the difference between assignment through a
<tt><A href="Container.html">Container</A>::iterator</tt> and assignment through an
<tt>insert_iterator&lt;<A href="Container.html">Container</A>&gt;</tt>.  If <tt>i</tt> is a valid
<tt><A href="Sequence.html">Sequence</A>::iterator</tt>, then it points to some particular
element in the <A href="Container.html">container</A>; the expression <tt>*i = t</tt> 
replaces that element with <tt>t</tt>, and does not change the total number
of elements in the <A href="Container.html">container</A>.  If <tt>ii</tt> is a valid
<tt>insert_iterator&lt;<A href="Container.html">container</A>&gt;</tt>, however, then 
the expression <tt>*ii = t</tt> is equivalent, for some <tt><A href="Container.html">container</A></tt>
<tt>c</tt> and some valid <tt><A href="Container.html">container</A>::iterator j</tt>, to the 
expression <tt>c.insert(j, t)</tt>.  That is, it does not overwrite
any of <tt>c</tt>'s elements and it does change <tt>c</tt>'s size.
<P><A name="2">[2]</A>
Note how assignment through an <tt>insert_iterator</tt> is implemented.
In general, unary <tt>operator*</tt> must be defined so that it returns a
proxy object, where the proxy object defines <tt>operator=</tt> to perform
the insert operation.  In this case, for the sake of simplicity, the
proxy object is the <tt>insert_iterator</tt> itself.  That is, <tt>*i</tt> simply
returns <tt>i</tt>, and <tt>*i = t</tt> is equivalent to <tt>i = t</tt>.  You should not,
however, rely on this behavior.  It is an implementation detail,
and it is not guaranteed to remain the same in future versions.
<P><A name="3">[3]</A>
This function exists solely for the sake of convenience:
since it is a non-member function, the template parameters may be
inferred and the type of the <tt>insert_iterator</tt> need not be declared
explicitly.  One easy way to reverse a range and insert it
into a <A href="Sequence.html">Sequence</A> <tt>S</tt>, for example, is
<tt><A href="reverse_copy.html">reverse_copy</A>(first, last, inserter(S, S.begin()))</tt>.
<h3>See also</h3>
<A href="front_insert_iterator.html">front_insert_iterator</A>, <A href="back_insert_iterator.html">back_insert_iterator</A>, <A href="OutputIterator.html">Output Iterator</A>,
<A href="Sequence.html">Sequence</A>, <A href="Iterators.html">Iterator overview</A>

<!--start footer--> 
<HR SIZE="6">
<A href="http://www.sgi.com/"><IMG SRC="surf.gif" HEIGHT="54" WIDTH="54" 
        ALT="[Silicon Surf]"></A>
<A HREF="index.html"><IMG SRC="stl_home.gif" 
        HEIGHT="54" WIDTH="54" ALT="[STL Home]"></A>
<BR>
<FONT SIZE="-2">
<A href="http://www.sgi.com/Misc/sgi_info.html" TARGET="_top">Copyright &copy; 
1999 Silicon Graphics, Inc.</A> All Rights Reserved.</FONT>
<FONT SIZE="-3"><a href="http://www.sgi.com/Misc/external.list.html" TARGET="_top">TrademarkInformation</A>
</FONT>
<P>
</BODY>
</HTML> 
